home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / email / _parseaddr.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  12.8 KB  |  539 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Email address parsing code.
  5.  
  6. Lifted directly from rfc822.py.  This should eventually be rewritten.
  7. '''
  8. import time
  9. SPACE = ' '
  10. EMPTYSTRING = ''
  11. COMMASPACE = ', '
  12. _monthnames = [
  13.     'jan',
  14.     'feb',
  15.     'mar',
  16.     'apr',
  17.     'may',
  18.     'jun',
  19.     'jul',
  20.     'aug',
  21.     'sep',
  22.     'oct',
  23.     'nov',
  24.     'dec',
  25.     'january',
  26.     'february',
  27.     'march',
  28.     'april',
  29.     'may',
  30.     'june',
  31.     'july',
  32.     'august',
  33.     'september',
  34.     'october',
  35.     'november',
  36.     'december']
  37. _daynames = [
  38.     'mon',
  39.     'tue',
  40.     'wed',
  41.     'thu',
  42.     'fri',
  43.     'sat',
  44.     'sun']
  45. _timezones = {
  46.     'UT': 0,
  47.     'UTC': 0,
  48.     'GMT': 0,
  49.     'Z': 0,
  50.     'AST': -400,
  51.     'ADT': -300,
  52.     'EST': -500,
  53.     'EDT': -400,
  54.     'CST': -600,
  55.     'CDT': -500,
  56.     'MST': -700,
  57.     'MDT': -600,
  58.     'PST': -800,
  59.     'PDT': -700 }
  60.  
  61. def parsedate_tz(data):
  62.     '''Convert a date string to a time tuple.
  63.  
  64.     Accounts for military timezones.
  65.     '''
  66.     data = data.split()
  67.     if data[0].endswith(',') or data[0].lower() in _daynames:
  68.         del data[0]
  69.     else:
  70.         i = data[0].rfind(',')
  71.         if i >= 0:
  72.             data[0] = data[0][i + 1:]
  73.         
  74.     if len(data) == 3:
  75.         stuff = data[0].split('-')
  76.         if len(stuff) == 3:
  77.             data = stuff + data[1:]
  78.         
  79.     
  80.     if len(data) == 4:
  81.         s = data[3]
  82.         i = s.find('+')
  83.         if i > 0:
  84.             data[3:] = [
  85.                 s[:i],
  86.                 s[i + 1:]]
  87.         else:
  88.             data.append('')
  89.     
  90.     if len(data) < 5:
  91.         return None
  92.     
  93.     data = data[:5]
  94.     (dd, mm, yy, tm, tz) = data
  95.     mm = mm.lower()
  96.     if mm not in _monthnames:
  97.         dd = mm
  98.         mm = dd.lower()
  99.         if mm not in _monthnames:
  100.             return None
  101.         
  102.     
  103.     mm = _monthnames.index(mm) + 1
  104.     if mm > 12:
  105.         mm -= 12
  106.     
  107.     if dd[-1] == ',':
  108.         dd = dd[:-1]
  109.     
  110.     i = yy.find(':')
  111.     if i > 0:
  112.         yy = tm
  113.         tm = yy
  114.     
  115.     if yy[-1] == ',':
  116.         yy = yy[:-1]
  117.     
  118.     if not yy[0].isdigit():
  119.         yy = tz
  120.         tz = yy
  121.     
  122.     if tm[-1] == ',':
  123.         tm = tm[:-1]
  124.     
  125.     tm = tm.split(':')
  126.     if len(tm) == 2:
  127.         (thh, tmm) = tm
  128.         tss = '0'
  129.     elif len(tm) == 3:
  130.         (thh, tmm, tss) = tm
  131.     else:
  132.         return None
  133.     
  134.     try:
  135.         yy = int(yy)
  136.         dd = int(dd)
  137.         thh = int(thh)
  138.         tmm = int(tmm)
  139.         tss = int(tss)
  140.     except ValueError:
  141.         return None
  142.  
  143.     tzoffset = None
  144.     tz = tz.upper()
  145.     if _timezones.has_key(tz):
  146.         tzoffset = _timezones[tz]
  147.     else:
  148.         
  149.         try:
  150.             tzoffset = int(tz)
  151.         except ValueError:
  152.             pass
  153.  
  154.     if tzoffset:
  155.         if tzoffset < 0:
  156.             tzsign = -1
  157.             tzoffset = -tzoffset
  158.         else:
  159.             tzsign = 1
  160.         tzoffset = tzsign * ((tzoffset // 100) * 3600 + (tzoffset % 100) * 60)
  161.     
  162.     tuple = (yy, mm, dd, thh, tmm, tss, 0, 1, 0, tzoffset)
  163.     return tuple
  164.  
  165.  
  166. def parsedate(data):
  167.     '''Convert a time string to a time tuple.'''
  168.     t = parsedate_tz(data)
  169.     if isinstance(t, tuple):
  170.         return t[:9]
  171.     else:
  172.         return t
  173.  
  174.  
  175. def mktime_tz(data):
  176.     '''Turn a 10-tuple as returned by parsedate_tz() into a UTC timestamp.'''
  177.     if data[9] is None:
  178.         return time.mktime(data[:8] + (-1,))
  179.     else:
  180.         t = time.mktime(data[:8] + (0,))
  181.         return t - data[9] - time.timezone
  182.  
  183.  
  184. def quote(str):
  185.     '''Add quotes around a string.'''
  186.     return str.replace('\\', '\\\\').replace('"', '\\"')
  187.  
  188.  
  189. class AddrlistClass:
  190.     '''Address parser class by Ben Escoto.
  191.  
  192.     To understand what this class does, it helps to have a copy of RFC 2822 in
  193.     front of you.
  194.  
  195.     Note: this class interface is deprecated and may be removed in the future.
  196.     Use rfc822.AddressList instead.
  197.     '''
  198.     
  199.     def __init__(self, field):
  200.         """Initialize a new instance.
  201.  
  202.         `field' is an unparsed address header field, containing
  203.         one or more addresses.
  204.         """
  205.         self.specials = '()<>@,:;."[]'
  206.         self.pos = 0
  207.         self.LWS = ' \t'
  208.         self.CR = '\r\n'
  209.         self.atomends = self.specials + self.LWS + self.CR
  210.         self.phraseends = self.atomends.replace('.', '')
  211.         self.field = field
  212.         self.commentlist = []
  213.  
  214.     
  215.     def gotonext(self):
  216.         '''Parse up to the start of the next address.'''
  217.         while self.pos < len(self.field):
  218.             if self.field[self.pos] in self.LWS + '\n\r':
  219.                 self.pos += 1
  220.                 continue
  221.             self
  222.             if self.field[self.pos] == '(':
  223.                 self.commentlist.append(self.getcomment())
  224.                 continue
  225.             break
  226.  
  227.     
  228.     def getaddrlist(self):
  229.         '''Parse all addresses.
  230.  
  231.         Returns a list containing all of the addresses.
  232.         '''
  233.         result = []
  234.         while self.pos < len(self.field):
  235.             ad = self.getaddress()
  236.             if ad:
  237.                 result += ad
  238.                 continue
  239.             result.append(('', ''))
  240.         return result
  241.  
  242.     
  243.     def getaddress(self):
  244.         '''Parse the next address.'''
  245.         self.commentlist = []
  246.         self.gotonext()
  247.         oldpos = self.pos
  248.         oldcl = self.commentlist
  249.         plist = self.getphraselist()
  250.         self.gotonext()
  251.         returnlist = []
  252.         if self.pos >= len(self.field):
  253.             if plist:
  254.                 returnlist = [
  255.                     (SPACE.join(self.commentlist), plist[0])]
  256.             
  257.         elif self.field[self.pos] in '.@':
  258.             self.pos = oldpos
  259.             self.commentlist = oldcl
  260.             addrspec = self.getaddrspec()
  261.             returnlist = [
  262.                 (SPACE.join(self.commentlist), addrspec)]
  263.         elif self.field[self.pos] == ':':
  264.             returnlist = []
  265.             fieldlen = len(self.field)
  266.             self.pos += 1
  267.             while self.pos < len(self.field):
  268.                 self.gotonext()
  269.                 returnlist = returnlist + self.getaddress()
  270.                 continue
  271.                 None if self.pos < fieldlen and self.field[self.pos] == ';' else self
  272.         elif self.field[self.pos] == '<':
  273.             routeaddr = self.getrouteaddr()
  274.             if self.commentlist:
  275.                 returnlist = [
  276.                     (SPACE.join(plist) + ' (' + ' '.join(self.commentlist) + ')', routeaddr)]
  277.             else:
  278.                 returnlist = [
  279.                     (SPACE.join(plist), routeaddr)]
  280.         elif plist:
  281.             returnlist = [
  282.                 (SPACE.join(self.commentlist), plist[0])]
  283.         elif self.field[self.pos] in self.specials:
  284.             self.pos += 1
  285.         
  286.         self.gotonext()
  287.         if self.pos < len(self.field) and self.field[self.pos] == ',':
  288.             self.pos += 1
  289.         
  290.         return returnlist
  291.  
  292.     
  293.     def getrouteaddr(self):
  294.         '''Parse a route address (Return-path value).
  295.  
  296.         This method just skips all the route stuff and returns the addrspec.
  297.         '''
  298.         if self.field[self.pos] != '<':
  299.             return None
  300.         
  301.         expectroute = False
  302.         self.pos += 1
  303.         self.gotonext()
  304.         adlist = ''
  305.         while self.pos < len(self.field):
  306.             if expectroute:
  307.                 self.getdomain()
  308.                 expectroute = False
  309.             elif self.field[self.pos] == '>':
  310.                 self.pos += 1
  311.                 break
  312.             elif self.field[self.pos] == '@':
  313.                 self.pos += 1
  314.                 expectroute = True
  315.             elif self.field[self.pos] == ':':
  316.                 self.pos += 1
  317.             else:
  318.                 adlist = self.getaddrspec()
  319.                 self.pos += 1
  320.                 break
  321.             self.gotonext()
  322.             continue
  323.             self
  324.         return adlist
  325.  
  326.     
  327.     def getaddrspec(self):
  328.         '''Parse an RFC 2822 addr-spec.'''
  329.         aslist = []
  330.         self.gotonext()
  331.         while self.pos < len(self.field):
  332.             if self.field[self.pos] == '.':
  333.                 aslist.append('.')
  334.                 self.pos += 1
  335.             elif self.field[self.pos] == '"':
  336.                 aslist.append('"%s"' % self.getquote())
  337.             elif self.field[self.pos] in self.atomends:
  338.                 break
  339.             else:
  340.                 aslist.append(self.getatom())
  341.             self.gotonext()
  342.         if self.pos >= len(self.field) or self.field[self.pos] != '@':
  343.             return EMPTYSTRING.join(aslist)
  344.         
  345.         aslist.append('@')
  346.         self.pos += 1
  347.         self.gotonext()
  348.         return EMPTYSTRING.join(aslist) + self.getdomain()
  349.  
  350.     
  351.     def getdomain(self):
  352.         '''Get the complete domain name from an address.'''
  353.         sdlist = []
  354.         while self.pos < len(self.field):
  355.             if self.field[self.pos] in self.LWS:
  356.                 self.pos += 1
  357.                 continue
  358.             self
  359.             if self.field[self.pos] == '(':
  360.                 self.commentlist.append(self.getcomment())
  361.                 continue
  362.             if self.field[self.pos] == '[':
  363.                 sdlist.append(self.getdomainliteral())
  364.                 continue
  365.             if self.field[self.pos] == '.':
  366.                 self.pos += 1
  367.                 sdlist.append('.')
  368.                 continue
  369.             self
  370.             if self.field[self.pos] in self.atomends:
  371.                 break
  372.                 continue
  373.             sdlist.append(self.getatom())
  374.         return EMPTYSTRING.join(sdlist)
  375.  
  376.     
  377.     def getdelimited(self, beginchar, endchars, allowcomments = True):
  378.         """Parse a header fragment delimited by special characters.
  379.  
  380.         `beginchar' is the start character for the fragment.
  381.         If self is not looking at an instance of `beginchar' then
  382.         getdelimited returns the empty string.
  383.  
  384.         `endchars' is a sequence of allowable end-delimiting characters.
  385.         Parsing stops when one of these is encountered.
  386.  
  387.         If `allowcomments' is non-zero, embedded RFC 2822 comments are allowed
  388.         within the parsed fragment.
  389.         """
  390.         if self.field[self.pos] != beginchar:
  391.             return ''
  392.         
  393.         slist = [
  394.             '']
  395.         quote = False
  396.         self.pos += 1
  397.         while self.pos < len(self.field):
  398.             if quote:
  399.                 slist.append(self.field[self.pos])
  400.                 quote = False
  401.             elif self.field[self.pos] in endchars:
  402.                 self.pos += 1
  403.                 break
  404.             elif allowcomments and self.field[self.pos] == '(':
  405.                 slist.append(self.getcomment())
  406.             elif self.field[self.pos] == '\\':
  407.                 quote = True
  408.             else:
  409.                 slist.append(self.field[self.pos])
  410.             self.pos += 1
  411.             continue
  412.             self
  413.         return EMPTYSTRING.join(slist)
  414.  
  415.     
  416.     def getquote(self):
  417.         """Get a quote-delimited fragment from self's field."""
  418.         return self.getdelimited('"', '"\r', False)
  419.  
  420.     
  421.     def getcomment(self):
  422.         """Get a parenthesis-delimited fragment from self's field."""
  423.         return self.getdelimited('(', ')\r', True)
  424.  
  425.     
  426.     def getdomainliteral(self):
  427.         '''Parse an RFC 2822 domain-literal.'''
  428.         return '[%s]' % self.getdelimited('[', ']\r', False)
  429.  
  430.     
  431.     def getatom(self, atomends = None):
  432.         """Parse an RFC 2822 atom.
  433.  
  434.         Optional atomends specifies a different set of end token delimiters
  435.         (the default is to use self.atomends).  This is used e.g. in
  436.         getphraselist() since phrase endings must not include the `.' (which
  437.         is legal in phrases)."""
  438.         atomlist = [
  439.             '']
  440.         if atomends is None:
  441.             atomends = self.atomends
  442.         
  443.         while self.pos < len(self.field):
  444.             if self.field[self.pos] in atomends:
  445.                 break
  446.             else:
  447.                 atomlist.append(self.field[self.pos])
  448.             self.pos += 1
  449.             continue
  450.             self
  451.         return EMPTYSTRING.join(atomlist)
  452.  
  453.     
  454.     def getphraselist(self):
  455.         '''Parse a sequence of RFC 2822 phrases.
  456.  
  457.         A phrase is a sequence of words, which are in turn either RFC 2822
  458.         atoms or quoted-strings.  Phrases are canonicalized by squeezing all
  459.         runs of continuous whitespace into one space.
  460.         '''
  461.         plist = []
  462.         while self.pos < len(self.field):
  463.             if self.field[self.pos] in self.LWS:
  464.                 self.pos += 1
  465.                 continue
  466.             self
  467.             if self.field[self.pos] == '"':
  468.                 plist.append(self.getquote())
  469.                 continue
  470.             if self.field[self.pos] == '(':
  471.                 self.commentlist.append(self.getcomment())
  472.                 continue
  473.             if self.field[self.pos] in self.phraseends:
  474.                 break
  475.                 continue
  476.             plist.append(self.getatom(self.phraseends))
  477.         return plist
  478.  
  479.  
  480.  
  481. class AddressList(AddrlistClass):
  482.     '''An AddressList encapsulates a list of parsed RFC 2822 addresses.'''
  483.     
  484.     def __init__(self, field):
  485.         AddrlistClass.__init__(self, field)
  486.         if field:
  487.             self.addresslist = self.getaddrlist()
  488.         else:
  489.             self.addresslist = []
  490.  
  491.     
  492.     def __len__(self):
  493.         return len(self.addresslist)
  494.  
  495.     
  496.     def __add__(self, other):
  497.         newaddr = AddressList(None)
  498.         newaddr.addresslist = self.addresslist[:]
  499.         for x in other.addresslist:
  500.             if x not in self.addresslist:
  501.                 newaddr.addresslist.append(x)
  502.                 continue
  503.         
  504.         return newaddr
  505.  
  506.     
  507.     def __iadd__(self, other):
  508.         for x in other.addresslist:
  509.             if x not in self.addresslist:
  510.                 self.addresslist.append(x)
  511.                 continue
  512.         
  513.         return self
  514.  
  515.     
  516.     def __sub__(self, other):
  517.         newaddr = AddressList(None)
  518.         for x in self.addresslist:
  519.             if x not in other.addresslist:
  520.                 newaddr.addresslist.append(x)
  521.                 continue
  522.         
  523.         return newaddr
  524.  
  525.     
  526.     def __isub__(self, other):
  527.         for x in other.addresslist:
  528.             if x in self.addresslist:
  529.                 self.addresslist.remove(x)
  530.                 continue
  531.         
  532.         return self
  533.  
  534.     
  535.     def __getitem__(self, index):
  536.         return self.addresslist[index]
  537.  
  538.  
  539.